Circuit Breaker Python : Construire des applications tolérantes aux pannes et résilientes

Dans le monde du développement logiciel, en particulier lorsqu'il s'agit de systèmes distribués et de microservices, les applications sont intrinsèquement sujettes aux pannes. Ces pannes peuvent provenir de diverses sources, notamment des problèmes de réseau, des pannes de service temporaires et des ressources surchargées. Sans une gestion appropriée, ces pannes peuvent se propager dans tout le système, entraînant une panne complète et une mauvaise expérience utilisateur. C'est là que le modèle Circuit Breaker entre en jeu - un modèle de conception crucial pour la construction d'applications tolérantes aux pannes et résilientes.

Comprendre la tolérance aux pannes et la résilience

Avant de plonger dans le modèle Circuit Breaker, il est essentiel de comprendre les concepts de tolérance aux pannes et de résilience :

• Tolérance aux pannes : La capacité d'un système à continuer de fonctionner correctement même en présence de pannes. Il s'agit de minimiser l'impact des erreurs et de garantir que le système reste fonctionnel.
• Résilience : La capacité d'un système à se remettre des pannes et à s'adapter aux conditions changeantes. Il s'agit de rebondir après les erreurs et de maintenir un niveau de performance élevé.

Le modèle Circuit Breaker est un élément clé pour atteindre à la fois la tolérance aux pannes et la résilience.

Le modèle Circuit Breaker expliqué

Le modèle Circuit Breaker est un modèle de conception logicielle utilisé pour prévenir les pannes en cascade dans les systèmes distribués. Il agit comme une couche de protection, surveillant l'état des services distants et empêchant l'application de tenter à plusieurs reprises des opérations susceptibles d'échouer. Ceci est crucial pour éviter l'épuisement des ressources et assurer la stabilité globale du système.

Pensez-y comme un disjoncteur électrique dans votre maison. Lorsqu'un défaut se produit (par exemple, un court-circuit), le disjoncteur se déclenche, empêchant le courant de circuler et causant d'autres dommages. De même, le Circuit Breaker surveille les appels aux services distants. Si les appels échouent à plusieurs reprises, le disjoncteur « se déclenche », empêchant d'autres appels à ce service jusqu'à ce que le service soit considéré comme sain.

Les états d'un Circuit Breaker

Un Circuit Breaker fonctionne généralement dans trois états :

• Fermé : L'état par défaut. Le Circuit Breaker autorise les requêtes à passer au service distant. Il surveille le succès ou l'échec de ces requêtes. Si le nombre d'échecs dépasse un seuil prédéfini dans une fenêtre temporelle spécifique, le Circuit Breaker passe à l'état « Ouvert ».
• Ouvert : Dans cet état, le Circuit Breaker rejette immédiatement toutes les requêtes, renvoyant une erreur (par exemple, un `CircuitBreakerError`) à l'application appelante sans tenter de contacter le service distant. Après une période de délai d'attente prédéfinie, le Circuit Breaker passe à l'état « Semi-ouvert ».
• Semi-ouvert : Dans cet état, le Circuit Breaker autorise un nombre limité de requêtes à passer au service distant. Ceci est fait pour tester si le service a récupéré. Si ces requêtes réussissent, le Circuit Breaker repasse à l'état « Fermé ». Si elles échouent, il revient à l'état « Ouvert ».

Avantages de l'utilisation d'un Circuit Breaker

• Tolérance aux pannes améliorée : Empêche les pannes en cascade en isolant les services défectueux.
• Résilience améliorée : Permet au système de se remettre des pannes en douceur.
• Consommation de ressources réduite : Évite le gaspillage de ressources sur des requêtes en échec répétées.
• Meilleure expérience utilisateur : Empêche les longs délais d'attente et les applications qui ne répondent pas.
• Gestion des erreurs simplifiée : Fournit un moyen cohérent de gérer les échecs.

Implémentation d'un Circuit Breaker en Python

Explorons comment implémenter le modèle Circuit Breaker en Python. Nous commencerons par une implémentation de base, puis ajouterons des fonctionnalités plus avancées comme les seuils d'échec et les périodes de délai d'attente.

Implémentation de base

Voici un exemple simple d'une classe Circuit Breaker :

            
import time

class CircuitBreaker:
 def __init__(self, service_function, failure_threshold=3, retry_timeout=10):
 self.service_function = service_function
 self.failure_threshold = failure_threshold
 self.retry_timeout = retry_timeout
 self.state = 'closed'
 self.failure_count = 0
 self.last_failure_time = None

 def __call__(self, *args, **kwargs):
 if self.state == 'open':
 if time.time() - self.last_failure_time < self.retry_timeout:
 raise Exception('Circuit is open')
 else:
 self.state = 'half-open'

 if self.state == 'half_open':
 try:
 result = self.service_function(*args, **kwargs)
 self.state = 'closed'
 self.failure_count = 0
 return result
 except Exception as e:
 self.failure_count += 1
 self.last_failure_time = time.time()
 self.state = 'open'
 raise e

 if self.state == 'closed':
 try:
 result = self.service_function(*args, **kwargs)
 self.failure_count = 0
 return result
 except Exception as e:
 self.failure_count += 1
 if self.failure_count >= self.failure_threshold:
 self.state = 'open'
 self.last_failure_time = time.time()
 raise Exception('Circuit is open') from e
 raise e

            

              
                Copy
              
            
          

Explication :

• `__init__` : Initialise le CircuitBreaker avec la fonction de service à appeler, un seuil d'échec et un délai d'attente de nouvelle tentative.
• `__call__` : Cette méthode intercepte les appels à la fonction de service et gère la logique du Circuit Breaker.
• État fermé : Appelle la fonction de service. Si cela échoue, incrémente `failure_count`. Si `failure_count` dépasse `failure_threshold`, il passe à l'état « Ouvert ».
• État ouvert : Déclenche immédiatement une exception, empêchant d'autres appels au service. Après le `retry_timeout`, il passe à l'état « Semi-ouvert ».
• État semi-ouvert : Autorise un seul appel de test au service. S'il réussit, le Circuit Breaker revient à l'état « Fermé ». S'il échoue, il revient à l'état « Ouvert ».

Exemple d'utilisation

Démontrons comment utiliser ce Circuit Breaker :

            
import time
import random

def my_service(success_rate=0.8):
 if random.random() < success_rate:
 return "Success!"
 else:
 raise Exception("Service failed")


circuit_breaker = CircuitBreaker(my_service, failure_threshold=2, retry_timeout=5)

for i in range(10):
 try:
 result = circuit_breaker()
 print(f"Attempt {i+1}: {result}")
 except Exception as e:
 print(f"Attempt {i+1}: Error: {e}")
 time.sleep(1)

            

              
                Copy
              
            
          

Dans cet exemple, `my_service` simule un service qui échoue occasionnellement. Le Circuit Breaker surveille le service et, après un certain nombre d'échecs, « ouvre » le circuit, empêchant d'autres appels. Après une période de délai d'attente, il passe en « semi-ouvert » pour tester à nouveau le service.

Ajout de fonctionnalités avancées

L'implémentation de base peut être étendue pour inclure des fonctionnalités plus avancées :

• Délai d'attente pour les appels de service : Mettre en œuvre un mécanisme de délai d'attente pour empêcher le Circuit Breaker de rester bloqué si le service met trop de temps à répondre.
• Surveillance et journalisation : Enregistrer les transitions d'état et les échecs pour la surveillance et le débogage.
• Métriques et rapports : Collecter des métriques sur les performances du Circuit Breaker (par exemple, nombre d'appels, échecs, temps d'ouverture) et les signaler à un système de surveillance.
• Configuration : Autoriser la configuration du seuil d'échec, du délai d'attente de nouvelle tentative et d'autres paramètres via des fichiers de configuration ou des variables d'environnement.

Implémentation améliorée avec délai d'attente et journalisation

Voici une version affinée intégrant des délais d'attente et une journalisation de base :

            
import time
import logging
import functools

logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')

class CircuitBreaker:
 def __init__(self, service_function, failure_threshold=3, retry_timeout=10, timeout=5):
 self.service_function = service_function
 self.failure_threshold = failure_threshold
 self.retry_timeout = retry_timeout
 self.timeout = timeout
 self.state = 'closed'
 self.failure_count = 0
 self.last_failure_time = None
 self.logger = logging.getLogger(__name__)

 @staticmethod
 def _timeout(func, timeout): #Decorator
 @functools.wraps(func)
 def wrapper(*args, **kwargs):
 import signal

 def handler(signum, frame):
 raise TimeoutError("Function call timed out")

 signal.signal(signal.SIGALRM, handler)
 signal.alarm(timeout)
 try:
 result = func(*args, **kwargs)
 signal.alarm(0)
 return result
 except TimeoutError:
 raise
 except Exception as e:
 raise
 finally:
 signal.alarm(0)
 return wrapper


 def __call__(self, *args, **kwargs):
 if self.state == 'open':
 if time.time() - self.last_failure_time < self.retry_timeout:
 self.logger.warning('Circuit is open, rejecting request')
 raise Exception('Circuit is open')
 else:
 self.logger.info('Circuit is half-open')
 self.state = 'half_open'

 if self.state == 'half_open':
 try:
 result = self._timeout(self.service_function, self.timeout)(*args, **kwargs)
 self.logger.info('Circuit is closed after successful half-open call')
 self.state = 'closed'
 self.failure_count = 0
 return result
 except TimeoutError as e:
 self.failure_count += 1
 self.last_failure_time = time.time()
 self.logger.error(f'Half-open call timed out: {e}')
 self.state = 'open'
 raise e
 except Exception as e:
 self.failure_count += 1
 self.last_failure_time = time.time()
 self.logger.error(f'Half-open call failed: {e}')
 self.state = 'open'
 raise e

 if self.state == 'closed':
 try:
 result = self._timeout(self.service_function, self.timeout)(*args, **kwargs)
 self.failure_count = 0
 return result
 except TimeoutError as e:
 self.failure_count += 1
 if self.failure_count >= self.failure_threshold:
 self.logger.error(f'Service timed out repeatedly, opening circuit: {e}')
 self.state = 'open'
 self.last_failure_time = time.time()
 raise Exception('Circuit is open') from e
 self.logger.error(f'Service timed out: {e}')
 raise e
 except Exception as e:
 self.failure_count += 1
 if self.failure_count >= self.failure_threshold:
 self.logger.error(f'Service failed repeatedly, opening circuit: {e}')
 self.state = 'open'
 self.last_failure_time = time.time()
 raise Exception('Circuit is open') from e
 self.logger.error(f'Service failed: {e}')
 raise e

            

              
                Copy
              
            
          

Améliorations clés :

• Délai d'attente : Implémenté à l'aide du module `signal` pour limiter le temps d'exécution de la fonction de service.
• Journalisation : Utilise le module `logging` pour enregistrer les transitions d'état, les erreurs et les avertissements. Cela facilite la surveillance du comportement du Circuit Breaker.
• Décorateur : L'implémentation du délai d'attente utilise désormais un décorateur pour un code plus propre et une applicabilité plus large.

Exemple d'utilisation (avec délai d'attente et journalisation)

            
import time
import random

def my_service(success_rate=0.8):
 time.sleep(random.uniform(0, 3))
 if random.random() < success_rate:
 return "Success!"
 else:
 raise Exception("Service failed")

circuit_breaker = CircuitBreaker(my_service, failure_threshold=2, retry_timeout=5, timeout=2)

for i in range(10):
 try:
 result = circuit_breaker()
 print(f"Attempt {i+1}: {result}")
 except Exception as e:
 print(f"Attempt {i+1}: Error: {e}")
 time.sleep(1)

            

              
                Copy
              
            
          

L'ajout du délai d'attente et de la journalisation améliore considérablement la robustesse et l'observabilité du Circuit Breaker.

Choisir la bonne implémentation de Circuit Breaker

Bien que les exemples fournis offrent un point de départ, vous pouvez envisager d'utiliser des bibliothèques ou des frameworks Python existants pour les environnements de production. Certaines options populaires incluent :

• Pybreaker : Une bibliothèque bien entretenue et riche en fonctionnalités fournissant une implémentation robuste de Circuit Breaker. Il prend en charge diverses configurations, métriques et transitions d'état.
• Resilience4j (avec wrapper Python) : Bien qu'il s'agisse principalement d'une bibliothèque Java, Resilience4j offre des capacités complètes de tolérance aux pannes, y compris les Circuit Breakers. Un wrapper Python peut être utilisé pour l'intégration.
• Implémentations personnalisées : Pour des besoins spécifiques ou des scénarios complexes, une implémentation personnalisée peut être nécessaire, permettant un contrôle total sur le comportement du Circuit Breaker et son intégration avec les systèmes de surveillance et de journalisation de l'application.

Meilleures pratiques en matière de Circuit Breaker

Pour utiliser efficacement le modèle Circuit Breaker, suivez ces bonnes pratiques :

• Choisissez un seuil d'échec approprié : Le seuil d'échec doit être soigneusement choisi en fonction du taux d'échec attendu du service distant. Définir le seuil trop bas peut conduire à des ruptures de circuit inutiles, tandis que le définir trop haut pourrait retarder la détection des véritables échecs. Tenez compte du taux d'échec typique.
• Définissez un délai d'attente de nouvelle tentative réaliste : Le délai d'attente de nouvelle tentative doit être suffisamment long pour permettre au service distant de récupérer, mais pas si long qu'il provoque des retards excessifs pour l'application appelante. Tenez compte de la latence du réseau et du temps de récupération du service.
• Mettre en œuvre la surveillance et les alertes : Surveillez les transitions d'état du Circuit Breaker, les taux d'échec et les durées d'ouverture. Configurez des alertes pour vous avertir lorsque le Circuit Breaker s'ouvre ou se ferme fréquemment ou si les taux d'échec augmentent. Ceci est crucial pour une gestion proactive.
• Configurez les Circuit Breakers en fonction des dépendances de service : Appliquez des Circuit Breakers aux services qui ont des dépendances externes ou qui sont essentiels à la fonctionnalité de l'application. Donnez la priorité à la protection des services critiques.
• Gérer correctement les erreurs du Circuit Breaker : Votre application doit être capable de gérer correctement les exceptions `CircuitBreakerError`, en fournissant des réponses alternatives ou des mécanismes de repli à l'utilisateur. Concevez pour une dégradation en douceur.
• Tenez compte de l'idempotence : Assurez-vous que les opérations effectuées par votre application sont idempotentes, en particulier lors de l'utilisation de mécanismes de nouvelle tentative. Cela évite les effets secondaires involontaires si une requête est exécutée plusieurs fois en raison d'une panne de service et de nouvelles tentatives.
• Utilisez les Circuit Breakers en conjonction avec d'autres modèles de tolérance aux pannes : Le modèle Circuit Breaker fonctionne bien avec d'autres modèles de tolérance aux pannes tels que les nouvelles tentatives et les cloisons pour fournir une solution complète. Cela crée une défense à plusieurs niveaux.
• Documentez votre configuration de Circuit Breaker : Documentez clairement la configuration de vos Circuit Breakers, y compris le seuil d'échec, le délai d'attente de nouvelle tentative et tous les autres paramètres pertinents. Cela assure la maintenabilité et permet un dépannage facile.

Exemples concrets et impact mondial

Le modèle Circuit Breaker est largement utilisé dans diverses industries et applications à travers le monde. Quelques exemples incluent :

• Commerce électronique : Lors du traitement des paiements ou de l'interaction avec les systèmes d'inventaire. (par exemple, les détaillants aux États-Unis et en Europe utilisent des Circuit Breakers pour gérer les pannes de passerelles de paiement.)
• Services financiers : Dans les services bancaires en ligne et les plateformes de trading, pour se protéger contre les problèmes de connectivité avec les API externes ou les flux de données de marché. (par exemple, les banques mondiales utilisent des Circuit Breakers pour gérer les cours boursiers en temps réel des bourses du monde entier.)
• Cloud Computing : Au sein des architectures de microservices, pour gérer les pannes de service et maintenir la disponibilité des applications. (par exemple, les grands fournisseurs de cloud comme AWS, Azure et Google Cloud Platform utilisent des Circuit Breakers en interne pour gérer les problèmes de service.)
• Soins de santé : Dans les systèmes fournissant des données patient ou interagissant avec les API des appareils médicaux. (par exemple, les hôpitaux au Japon et en Australie utilisent des Circuit Breakers dans leurs systèmes de gestion des patients.)
• Industrie du voyage : Lors de la communication avec les systèmes de réservation de compagnies aériennes ou les services de réservation d'hôtels. (par exemple, les agences de voyages opérant dans plusieurs pays utilisent des Circuit Breakers pour faire face aux API externes peu fiables.)

Ces exemples illustrent la polyvalence et l'importance du modèle Circuit Breaker dans la construction d'applications robustes et fiables qui peuvent résister aux pannes et offrir une expérience utilisateur transparente, quel que soit l'emplacement géographique de l'utilisateur.

Considérations avancées

Au-delà des bases, il existe des sujets plus avancés à considérer :

• Modèle de cloisonnement : Combinez les Circuit Breakers avec le modèle de cloisonnement pour isoler les pannes. Le modèle de cloisonnement limite le nombre de requêtes simultanées vers un service particulier, empêchant un seul service en panne de faire tomber l'ensemble du système.
• Limitation du débit : Mettez en œuvre une limitation du débit en conjonction avec les Circuit Breakers pour protéger les services contre la surcharge. Cela permet d'éviter qu'une inondation de requêtes ne submerge un service qui est déjà en difficulté.
• Transitions d'état personnalisées : Vous pouvez personnaliser les transitions d'état du Circuit Breaker pour implémenter une logique de gestion des pannes plus complexe.
• Circuit Breakers distribués : Dans un environnement distribué, vous pourriez avoir besoin d'un mécanisme pour synchroniser l'état des Circuit Breakers sur plusieurs instances de votre application. Envisagez d'utiliser un magasin de configuration centralisé ou un mécanisme de verrouillage distribué.
• Surveillance et tableaux de bord : Intégrez votre Circuit Breaker avec des outils de surveillance et de tableau de bord pour fournir une visibilité en temps réel sur l'état de vos services et les performances de vos Circuit Breakers.

Conclusion

Le modèle Circuit Breaker est un outil essentiel pour la création d'applications Python tolérantes aux pannes et résilientes, en particulier dans le contexte des systèmes distribués et des microservices. En implémentant ce modèle, vous pouvez améliorer considérablement la stabilité, la disponibilité et l'expérience utilisateur de vos applications. De la prévention des pannes en cascade à la gestion gracieuse des erreurs, le Circuit Breaker offre une approche proactive pour gérer les risques inhérents associés aux systèmes logiciels complexes. Son implémentation efficace, combinée à d'autres techniques de tolérance aux pannes, garantit que vos applications sont prêtes à relever les défis d'un paysage numérique en constante évolution.

En comprenant les concepts, en mettant en œuvre les meilleures pratiques et en tirant parti des bibliothèques Python disponibles, vous pouvez créer des applications plus robustes, fiables et conviviales pour un public mondial.